home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / haeberli / README.overview < prev   
Text File  |  1994-08-01  |  19KB  |  385 lines
  1.  
  2.  [the following is an ascii version of the paper given out at the developer's 
  3.   forum this past May, 1992, and was the companion to the Totally Insane (tm) 
  4.   CD accompanying tom davis' and paul haeberli's presentation.  all references
  5.   to the Totally Insame (tm) CD itself however have been supplanted with 
  6.   references to the developer's toolbox CD structure            -- ratitor   ]
  7.  
  8.  
  9.  
  10.                    Graphics Utility Tools and Libraries CD
  11.  
  12.                                Paul Haeberli 
  13.                        Silicon Graphics Computer Systems
  14.  
  15.  
  16.  
  17.                                  Abstract
  18.  
  19.      The Iris Graphics Library supports interactive drawing of lighted
  20.      3-D geometry, but sometimes the interface provided by the GL is
  21.      not the most convenient or general.  For example, filling concave
  22.      polygons or describing lighting can be complex and unpleasant tasks.
  23.      
  24.      This paper describes libraries and tools that are available to 
  25.      solve many common graphics problems.  These tools 
  26.      handle problems like triangulating concave regions for rapid display, 
  27.      drawing character strings using geometry, creating beveled
  28.      and extruded shapes, automatic generation of triangle meshes,
  29.      environment mapping 3-D geometry, dithering rgb images and drawing 
  30.      anti-aliased characters. 
  31.      
  32.  
  33.      
  34.                                Introduction
  35.      
  36.      A variety of graphics tools will be discussed.  Here's a brief 
  37.      overview: 
  38.      
  39.      Several image related library functions will be described, along 
  40.      with various conversion programs.  Then special image processing
  41.      tools for environment maps will be introduced.  
  42.      
  43.      After image related stuff, it's on to geometry.  We have a simple 
  44.      geometry format and a set of programs that can display or modify 
  45.      this geometry.  The complete source code to these programs is 
  46.      included.
  47.      
  48.      Next it's outline fonts.  There's a paint program for generating 
  49.      outline fonts and tools for transforming outline descriptions into 
  50.      filled characters using triangle meshes.  A library that draws 
  51.      anti-aliased characters is provided, along with tools for reading 
  52.      Adobe Type1 fonts and generating Type 3 fonts.
  53.      
  54.      Then, a few miscellaneous things are discussed, like a nice 
  55.      interface for viewing geometry, general dithering code and easier 
  56.      GL lighting.
  57.      
  58.      In addition to this, theres a whole bunch of other insane stuff.
  59.      You'll just have to read the rest of the paper to find out.  I can't
  60.      get everything into the stinking introduction!
  61.      
  62.  
  63.                               Acknowledgements
  64.      
  65.      The software described here was developed with the help of many
  66.      other people.  
  67.      
  68.       Kurt Akeley wrote the auto meshing functions & the geometry capping
  69.          example (located in toolbox/src/exampleCode/cap).
  70.       Ivan Bach wrote the DPSGLX demo (/toolbox/src/exampleCode/GLX/dpsglx).
  71.       Gavin Bell and Thant Tessman wrote the original virtual sphere
  72.          interface for viewing geometry.  
  73.       Forest Baskett kindly let us spend time on this.
  74.       David Brown made his face available in digital form.
  75.       Derrick Burns developed the concave polygon triangularization library
  76.          (toolbox/src/haeberli/lib/libtri.a).  
  77.       Nancy Cam provided the a image warping application called tiepoint
  78.          (toolbox/bin/tiepoint).
  79.       Simon Carter at Abekas provided code for converting between digital 
  80.          video format and rgb space (toolbox/src/haeberli/abekas).  
  81.       Kathy Chaix cleverly tricked us into organizing this CDROM.
  82.       Tom Davis contributed calc - a simple calculator 
  83.      (toolbox/src/exampleCode/calc), generic - a generic application 
  84.      template (toolbox/src/swtools/generic), geometer - a program for 
  85.      creating geometric proofs (toolbox/src/tutorials/geometer), 
  86.      3Dmodeling - a library for creating 3-D geometry 
  87.      (toolbox/src/exampleCode/3Dmodeling), and zip - a FAST editor for 
  88.      the IRIS (toolbox/bin/zip).
  89.       Dave Larson provided funding for publishing the CDROM.
  90.       Sam Leffler wrote the TIFF image library (toolbox/src/haeberli/libtiff).  
  91.       David Maynard developed the audio mesh application - amesh 
  92.      (toolbox/src/demos/audio/amesh).
  93.       Reuel Nash developed iso, an iso-surface rendering program 
  94.      (toolbox/src/exampleCode/iso). 
  95.       Dave Ratcliffe helped us get this source together.
  96.       Seth Teller wrote the font painting program and several of the other 
  97.          font tools.
  98.       Doug Voorhies developed mtex, a program to help make texture maps from
  99.          scanned images (toolbox/src/haeberli/mtex).
  100.      
  101.      This paper refers to various source files and programs.  These files 
  102.      are located on the "Totally Insane Graphics Tools and Utilties" CDROM.
  103.      
  104.  
  105.                                Image Stuff
  106.  
  107.      By an image, we mean a rectangular array of pixels.  On the Iris, we 
  108.      currently use our own SGI image file format to store image data.  This 
  109.      format is used for screen dumps and for printing.  A program called 
  110.      "ipaste" displays an Iris image on the screen.
  111.      
  112.      The Iris image library is called "libimage.a" and it is installed in 
  113.      /usr/lib on all Iris workstations.   You can look in the the directory
  114.      /toolbox/src/haeberli/libimage if you want to see the implementation of 
  115.      the actual image library.  Normally you will only need to call a few 
  116.      different routines in the image library to read or write an Iris image 
  117.      file, or you can make a single call to read all the pixels in an image 
  118.      into an array of longs.  Take a look at the program imgtools/rectimg.c 
  119.      as an example of how to read pixel data from an image file in a easy 
  120.      way.
  121.      
  122.      It's easy to write simple filters that operate on Iris images.  The 
  123.      source to a number of image processing programs can be found in the 
  124.      imgtools directory.  Some of these tools read and write other image 
  125.      file formats, while others operate on Iris image files.  A simple 
  126.      program that saturates an Iris image can be found in imgtools/saturate.c
  127.      
  128.      A few image tools deserve special note.  The programs "fromyuv" and 
  129.      "toyuv" convert between Abekas digital video images and Iris image 
  130.      files.  These tools can be used to record images from the Iris on a 
  131.      device that supports digital video data, or to make an image that can 
  132.      be displayed on the Iris.  Routines that generate and read digital 
  133.      video data can be found in libgutil/abekas.c
  134.      
  135.      A program called "gendit" supports general dithering of Iris images.  It 
  136.      takes an RGB image as input and writes out an RGB image with a smaller 
  137.      number of colors.  You can specify on the command line how many levels 
  138.      of red, green and blue may be used in the output image.  This program 
  139.      uses the code in libgutil/gendit.c to perform an ordered dither.  This 
  140.      dithering technique can be used to display good looking continuous tone 
  141.      images in the overlay planes or the underlay planes.
  142.      
  143.      At times you may need to resize an Iris image.  This can be done with 
  144.      the program "izoom".  The source can be found in imgtools/izoom.c  You 
  145.      can specify a floating point scale factor for resizing in x and y.  You 
  146.      can also specify the kind of filtering to use when resizing.
  147.      
  148.      The program "imgtools/scope" can be used to roam around very high 
  149.      resolution images quickly, examine actual pixels values in an image and 
  150.      determine exact pixel locations.
  151.      
  152.      The program "movie" lets you view a series of images as a movie loop. 
  153.      
  154.      Finally "scrsave" can be used to save an image from the screen as an 
  155.      Iris image file.  Take a look at the function savewindow in 
  156.      libgutil/glstuff.c.  It shows how to execute scrsave from inside a 
  157.      graphics program to save the current window as an image file.
  158.      
  159.  
  160.                              Tiff Library Support
  161.      
  162.      An important industry image file standard is the TIFF image format.  
  163.      Eventually we will be using TIFF as our standard image file format.  
  164.      You can find complete source to a library that reads and writes TIFF 
  165.      in public/tiff.  There are also two Iris programs in imgtools called 
  166.      "totiff" and "fromtiff" that can convert Iris images into tiff images 
  167.      and back.
  168.      
  169.  
  170.                             Environment Map Tools
  171.      
  172.      Environment or Reflection mapping is a technique that uses texture 
  173.      mapping to simulate the smooth shading of reflective surfaces.  It 
  174.      can be used to create very nice shading of more diffuse surfaces as 
  175.      well.  The program objtools/spin can be used to draw an object with 
  176.      environment mapping.  A variety of tools for creating and manipulating 
  177.      environment maps are provided in the envtools directory.
  178.      
  179.      The primary format of an environment map is a single Iris image file 
  180.      that has a 3 by 2 array of square images from 6 faces of a cube.  
  181.      Environment maps can be created in several ways.  One way is to take a 
  182.      180 degree fisheye picture of a scene, scan in this image and then 
  183.      project this onto the cubical format.  The program "envtools/fromfish" 
  184.      does exactly this.  The result of this is an image like those in the 
  185.      "envmaps" directory.
  186.      
  187.      These environment map images can be processed using the many of the  
  188.      Iris image tools.  But when it comes to doing area processes, special 
  189.      tools are needed.  The program "envreduce" zooms a cubical environment
  190.      map down by a factor of two, while the program "envexpand" zooms a 
  191.      cubical environment map up by a factor of two.  These two programs can
  192.      be used in sequence to blur cubical environment maps.
  193.      
  194.      In the IRIX 4.0 release, the VGX and Indigo machines have support for 
  195.      using the normal of surfaces to provide texture map coordinates for 
  196.      reflection mapping.  The format used for environment mapping is not a 
  197.      cubical format but a spherical format.  The program "envtools/sphereenv"
  198.      can be used to convert an environment map in cubical format into a 
  199.      spherical format.  When doing this you MUST use the "-s" option so a 
  200.      reflective sphere is rendered.  Other environment map creation tools 
  201.      are also available in the "envtools" directory.
  202.      
  203.      A collection of processed spherical environment maps can be found in 
  204.      the directory called "128env".  These can be used on machines that 
  205.      support texture mapping to render very nice looking surfaces.  We are 
  206.      actively collecting interesting reflection maps.  If you would like to 
  207.      contribute some, please let me know.
  208.      
  209.  
  210.                             Texture Map collection
  211.      
  212.      A small collection of 128x128 texture maps can be found in the 
  213.      directory called "128tex".  We are actively collecting interesting 
  214.      texture map images that are 128x128 or 256x256.  If you make some 
  215.      really neat textures, we would really like to include them in our 
  216.      collection!
  217.      
  218.  
  219.                            A Simple Geometry Format
  220.      
  221.      Over the past years we've had a lot of discussion about file formats 
  222.      for geometry.  It's a difficult and complex topic.  At one end of the 
  223.      scale you could use an interpreted language and at the other end of 
  224.      the scale you could just use a data structure for storing geometry.  
  225.      Languages have the advantage that they are very flexible and may be 
  226.      extended easily.  A simple geometry data structure has the advantage 
  227.      that you can easily define operations on objects.
  228.      
  229.      I have a simple format that I've been using for polygonal objects.  
  230.      The library source that suports this format is in libgutil/sgiobj.c
  231.      and libgutil/sgiobjgl.c.  Each sgo object is either a list or 
  232.      quadrilaterals, a list of triangles, or a list of triangle meshes.
  233.      Each vertex in one of these objects has a 3D position, a normal and
  234.      3 values that are either a RGB color or a texture map coordinate.
  235.      
  236.      A collection of sgo objects is provided in the "objects" directory.
  237.      Various tools for operating on these objects can be found in the 
  238.      "objtools" directory.  The program "spin" reads in one of these 
  239.      objects and lets the user control the scale and orientation of the 
  240.      object using a virtual sphere user interface.  Another tool "totri" 
  241.      transforms objects that are lists of quads into triangle list objects. 
  242.      The program "tomesh" converts a list of triangles into a triangle 
  243.      mesh object.  These tools use various functions from libgutil that 
  244.      support a simplified interface to describing shading, automatic 
  245.      triangle mesh generation and efficient drawing of geometry.
  246.      
  247.      The program "subdiv" subdivides a list of triangles object to insure
  248.      that no triangle in an object are larger than some specified size, 
  249.      while "explode" translates all vertices in the direction of their 
  250.      normal.  The program "sterrend" in the objtools directory shows how to 
  251.      display geometry using Red-Green Stereo, while "warpgeom" applies a 
  252.      deformation to a geometric object.
  253.      
  254.  
  255.                                   Font Tools
  256.      
  257.      I've developed a binary file format for storing fonts.  These fonts
  258.      can either be polygonal outlines (font.of), spline outlines (font.sp), 
  259.      or triangle meshes (font.mf).  The basic support for this file format
  260.      is in libgutil/objfnt.c, while libgutil/charfill.c has code that
  261.      creates and draws anti-aliased bitmaps of a outline font.  
  262.      
  263.      A collection of outline fonts is provided in the "fonts" directory . 
  264.      But new ones can easily be created using the programs in the 
  265.      "fonttools" directory.
  266.      
  267.      A program called "paintfont" allows you to paint each character to
  268.      define an outline font.  Each painting is autotraced to create 
  269.      polygonal outlines.  The code that converts an image into outlines is 
  270.      in libgutil/stream.c.  Once polygonal outlines are created, the 
  271.      program "adjustfont" can be used to adjust the character spacing and 
  272.      character widths in the outline font.
  273.      
  274.      You can see what anti-aliased renderings of the characters look like
  275.      by running "charfill".  Adobe Type1 fonts can be converted into
  276.      polygonal or spline format by using "fromtype1".  If you want to draw 
  277.      characters using triangle meshes, the program "meshfont" converts a 
  278.      font.of file into a font.mf file automatically.
  279.      
  280.      The program "bevelstring" can be used to create 3D geometry from a 
  281.      string of text.  This program uses the library code in libgutil/path.c
  282.      to provide support for describing and filling concave regions.
  283.      
  284.      If you want to make PostScript fonts that can be used with DPS or a 
  285.      laser printer, the program "makepsfont" can be used to generate a 
  286.      Type3 font and an AFM file.
  287.  
  288.      
  289.                             Audio Analysis Example
  290.      
  291.      Amesh (toolbox/src/demos/audio/amesh) is a program that makes audio 
  292.      visible by plotting a real-time history of sequential power spectra 
  293.      computed from an audio input stream. FFT-fu, Audio-fu; Paul-Bob sez: 
  294.      "Check it out".
  295.      
  296.  
  297.                         Making "Paintings" from Images
  298.      
  299.      The "impression" directory has tools for creating painted 
  300.      representations of scanned images interactively.  To give this a try, 
  301.      type "make demo" in the "impression" directory.  The other tools in 
  302.      this directory can be used to manipulate paintings described by a 
  303.      list of brush strokes.
  304.      
  305.      The "autopaint" directory  has tools for automatically creating 
  306.      paintings.  To try this out, type "make demo" in the "autopaint"
  307.      directory.
  308.      
  309.  
  310.                      A Little Paint Program for the Iris
  311.      
  312.      The "imp" directory has the source for a fun little paint program
  313.      for the IRIS.  It does all its drawing into memory and then copies
  314.      the result onto the screen.  You can zoom the canvas image up to do 
  315.      detailed work. To try this out, cd to "imp" and type "make demo".
  316.      This program uses the "libcan" library to blend brush strokes onto 
  317.      the canvas.
  318.      
  319.  
  320.                         Enhance Images Interactively
  321.      
  322.      The "enhance" directory has the source for an image enhancement
  323.      program that let's you enhance a source image by choosing an image 
  324.      processing operation, and then picking an image from a range of 
  325.      processed images.  To give this program a try, type "make demo" in 
  326.      the "enhance" directory.
  327.  
  328.      
  329.                        LEEP Projection for VR Display
  330.      
  331.      The program in "leep" implements the LEEP projection in software.
  332.      This maps a 140 degree viewing angle into a circle, as required by 
  333.      the optics provided by LEEP.  To try this out, cd to "leep" and type 
  334.      "make demo".
  335.  
  336.      
  337.                       Use Compression to Display Movies
  338.      
  339.      Take a look in the "movie" directory .  There is a program called
  340.      "mkmov" for compressing a series of images and another one called
  341.      "expmov" to display a compressed movie.  To see it go, you guessed it, 
  342.      just type "make demo".
  343.      
  344.                           Prepare Texture Map Images
  345.      
  346.      Look in the "mtex" directory.  This contains an image processing 
  347.      application that massages scanned images for use as texture maps.  It 
  348.      performs common operations such as color or contrast correction, 
  349.      cropping, and sharpening, plus unusual functions needed for texture 
  350.      maps.  These include making edges match so the image can be used as a 
  351.      tile, "homogenizing" a texture to eliminate splotchiness and 
  352.      gradations, and synthesizing an alpha channel from the color 
  353.      information.  
  354.  
  355.      
  356.                               Miscellaneous Goo
  357.      
  358.      The programs above rely on a collection of library routines that are 
  359.      in lib, libcan and libgutil.  These libraries support the virtual 
  360.      sphere user interface, automatic triangularization of complex concave 
  361.      areas, automatic triangle mesh generation, drawing of anti-aliased 
  362.      characters, conversion from RGB to CMYK space, and more.  There is also
  363.      a vector and matrix library, functions to help make it easier to use GL 
  364.      lighting and routines to generate PostScript images and drawings.
  365.      
  366.  
  367.                                  An Apology
  368.      
  369.      In keeping with the informal nature of this conference, we began
  370.      preparing this document at 2:30 for a 5:00 deadline, so there are
  371.      still a few things we didn't have time to describe.  This gives YOU
  372.      the opportunity to explore the following directories on your own:
  373.      Check out Tom Davis's stuff in toolbox/src/exampleCode/calc, 
  374.      toolbox/src/swtools/generic, toolbox/src/tutorials/geometer, 
  375.      toolbox/src/exampleCode/3Dmodeling and toolbox/bin/zip.  Then look at 
  376.      toolbox/src/exampleCode/cap, compexp, 
  377.      toolbox/src/exampleCode/GLX/dpsglx, toolbox/src/printers/dpsprint, 
  378.      toolbox/src/exampleCode/iso, styline, toolbox/bin/tiepoint, tools, 
  379.      and tools/tritest.
  380.      
  381.  
  382.      If you are interested you may want to compile the libraries and tools 
  383.      and take a look at the README files provided.  Good luck, and have fun!
  384.      
  385.